Computing the Girth of a Planar Graph in Linear Time

The girth of a graph is the minimum weight of all simple cycles of the graph. We study the problem of determining the girth of an n-node unweighted undirected planar graph. The first non-trivial algorithm for the problem, given by Djidjev, runs in O(n^{5/4} log n) time. Chalermsook, Fakcharoenphol, and Nanongkai reduced the running time to O(n log^2 n). Weimann and Yuster further reduced the running time to O(n log n). In this paper, we solve the problem in O(n) time.Comment: 20 pages, 7 figures, accepted to SIAM Journal on Computin

On-line and dynamic algorithms for shortest path problems

We describe algorithms for finding shortest paths and distances in a planar digraph which exploit the particular topology of the input graph. An important feature of our algorithms is that they can work in a dynamic environment, where the cost of any edge can be changed or the edge can be deleted. For outerplanar digraphs, for instance, the data structures can be updated after any such change in only $O(\log n)$ time, where $n$ is the number of vertices of the digraph. We also describe the first parallel algorithms for solving the dynamic version of the shortest path problem. Our results can be extended to hold for digraphs of genus $o(n)$

On-line and Dynamic Shortest Paths through Graph Decompositions (Preliminary Version)

We describe algorithms for finding shortest paths and distances in a planar digraph which exploit the particular topology of the input graph. We give both sequential and parallel algorithms that work on a dynamic environment, where the cost of any edge can be changed or the edge can be deleted. For outerplanar digraphs, for instance, the data structures can be updated after any such change in only $O(\log n)$ time, where $n$ is the number of vertices of the digraph. The parallel algorithms presented here are the first known ones for solving this problem. Our results can be extended to hold for digraphs of genus $o(n)$

Linear-Space Approximate Distance Oracles for Planar, Bounded-Genus, and Minor-Free Graphs

A (1 + eps)-approximate distance oracle for a graph is a data structure that supports approximate point-to-point shortest-path-distance queries. The most relevant measures for a distance-oracle construction are: space, query time, and preprocessing time. There are strong distance-oracle constructions known for planar graphs (Thorup, JACM'04) and, subsequently, minor-excluded graphs (Abraham and Gavoille, PODC'06). However, these require Omega(eps^{-1} n lg n) space for n-node graphs. We argue that a very low space requirement is essential. Since modern computer architectures involve hierarchical memory (caches, primary memory, secondary memory), a high memory requirement in effect may greatly increase the actual running time. Moreover, we would like data structures that can be deployed on small mobile devices, such as handhelds, which have relatively small primary memory. In this paper, for planar graphs, bounded-genus graphs, and minor-excluded graphs we give distance-oracle constructions that require only O(n) space. The big O hides only a fixed constant, independent of \epsilon and independent of genus or size of an excluded minor. The preprocessing times for our distance oracle are also faster than those for the previously known constructions. For planar graphs, the preprocessing time is O(n lg^2 n). However, our constructions have slower query times. For planar graphs, the query time is O(eps^{-2} lg^2 n). For our linear-space results, we can in fact ensure, for any delta > 0, that the space required is only 1 + delta times the space required just to represent the graph itself

A Planarity Test via Construction Sequences

Optimal linear-time algorithms for testing the planarity of a graph are well-known for over 35 years. However, these algorithms are quite involved and recent publications still try to give simpler linear-time tests. We give a simple reduction from planarity testing to the problem of computing a certain construction of a 3-connected graph. The approach is different from previous planarity tests; as key concept, we maintain a planar embedding that is 3-connected at each point in time. The algorithm runs in linear time and computes a planar embedding if the input graph is planar and a Kuratowski-subdivision otherwise

Linear Algorithms for Partitioning Embedded Graphs of Bounded Genus

This paper develops new techniques for constructing separators for graphs embedded on surfaces of bounded genus. For any arbitrarily small positive " we show that any n-vertex graph G of genus g can be divided in O(n + g) time into components whose sizes do not exceed "n by removing a set C of O( p (g + 1=")n) vertices. Our result improves the best previous ones with respect to the size of C and the time complexity of the algorithm. Moreover, we show that one can cut off from G a piece of no more than (1 \Gamma ")n vertices by removing a set of O( p n"(g" + 1) vertices. Both results are optimal up to a constant factor. Keywords: graph separator, graph genus, algorithm, divide-and-conquer, topological graph theory AMS(MOS) subject classifications: 05C10, 05C85, 68R10 1 Bulgarian Academy of Sci., CICT, G.Bonchev 25-A, 1113 Sofia, Bulgaria 2 Department of Comp.Sci.,Rice University, P.O.Box 1892, Houston, Texas 77251, USA 1 Introduction Let S be a class of graphs closed under t..